package com.gb.web.common.utils;

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoUnit;
import java.util.Calendar;
import java.util.Date;
import java.util.TimeZone;

public class DateUtil {
	 /**
     * 时间格式化
     */
    public static String formatDate(Date time, String format) {
        SimpleDateFormat df = new SimpleDateFormat(format);
        if (null != time) {
            return df.format(time);
        } else {
            return "";
        }
    }
    
    /**
     * @param date 字符型时间格式
     * */
    public static Date strFormatDate(String date, String format){
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        try {
            return sdf.parse(date);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return null;
    }
	

    /**
     * 时间字符串格式化
     */
    public static String formatStrDate(String dateStr, String beforeFormat, String afterFormat) {
        try {
            if (dateStr.length() != beforeFormat.length()) {
                return dateStr;
            }
            SimpleDateFormat bdf = new SimpleDateFormat(beforeFormat);
            SimpleDateFormat adf = new SimpleDateFormat(afterFormat);
            if (null != dateStr) {
                return adf.format(bdf.parse(dateStr));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return dateStr;
    }
	
	/**
	 * 获取当前时间的字符串（yyyyMMddHHmmss）
	 * @return
	 */
	public static String getTimestampStr(){
        SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmmss");
        return sdf.format(new Date());
    }
	
    /**
     * 日切日期减1
     * @param dailySwthchDate
     * @return
     */
	public static String convertDate(String dailySwthchDate) {
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
		Calendar ordcal = Calendar.getInstance();
		 String returnDate = null;
		try {
			Date orderDate = sdf.parse(dailySwthchDate);
		    ordcal.setTime(orderDate);
		} catch (Exception e) {
			  // 如果转化失败取当天时间
			ordcal.setTime(new Date());
		}finally{
			ordcal.add(Calendar.DATE, -1);
			returnDate = sdf.format(ordcal.getTime());
		}
		return returnDate;
	}
	
	
	//日期减一
	public static Integer lastDate(Integer date, String format) {
		SimpleDateFormat sdf = new SimpleDateFormat(format);
		try {
			Date orderDate = sdf.parse(String.valueOf(date));
			Calendar ordcal = Calendar.getInstance();
		    ordcal.setTime(orderDate);
		    ordcal.add(Calendar.DATE, -1);
            return Integer.valueOf(sdf.format(ordcal.getTime()));
		} catch (Exception e) {
			 sdf = new SimpleDateFormat("yyyyMMdd");
		     return Integer.valueOf(sdf.format(new Date()));
		}
	}
	
	/**
     * 日切日期加一减一天
     * @param dailySwthchDate
     * @return
     */
    public static String compaterDailyDate(String dailySwthchDate,int dayDate) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Calendar calendar = Calendar.getInstance();
        String returnDate = null;
        try {
            Date switchDate = sdf.parse(dailySwthchDate);
            calendar.setTime(switchDate);
        } catch (ParseException e) {
            // 如果转化失败取当天时间
            calendar.setTime(new Date());
        } finally {
            calendar.add(Calendar.DATE, dayDate);
            returnDate = sdf.format(calendar.getTime());
        }
        return returnDate;
    }
	
	/**
	 * 上日
	 */
	public static String formatDate(String sDate,String format){
		if(StringUtils.isEmpty(sDate)){
			return "";
		}
		 SimpleDateFormat df = new SimpleDateFormat(format);
		 Calendar cal  = null;
		 try {
			Date dDate = df.parse(sDate);
			cal = Calendar.getInstance();
			cal.setTime(dDate);
			cal.add(Calendar.DAY_OF_MONTH, -1);
		} catch (ParseException e) {
			e.printStackTrace();
		}
		return df.format(cal.getTime());
	}
	/**
	 * 下日
	 */
	public static String formatNextDate(String sDate,String format){
		if(StringUtils.isEmpty(sDate)){
			return "";
		}
		 SimpleDateFormat df = new SimpleDateFormat(format);
		 Calendar cal  = null;
		 try {
			Date dDate = df.parse(sDate);
			cal = Calendar.getInstance();
			cal.setTime(dDate);
			cal.add(Calendar.DAY_OF_MONTH, 1);
		} catch (ParseException e) {
			e.printStackTrace();
		}
		return df.format(cal.getTime());
	}
	
	public static Date formatStr2Date(String sDate,String format){
		if(StringUtils.isEmpty(sDate)){
			return null;
		}
		 SimpleDateFormat df = new SimpleDateFormat(format);
		 Calendar cal  = null;
		 try {
			Date dDate = df.parse(sDate);
			cal = Calendar.getInstance();
			cal.setTime(dDate);
		} catch (ParseException e) {
			e.printStackTrace();
		}
		return cal.getTime();
	}
	
	/**
	 * 获取上一日日期（yyyy-MM-dd）
	 * @return
	 */
	public static String getRoundDateString(){
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(new Date());
		calendar.add(Calendar.DAY_OF_MONTH, -1);
		Date date = calendar.getTime();
		return sdf.format(date);
	}
	
	public static String nextDate(String date, String format) {
		SimpleDateFormat sdf = new SimpleDateFormat(format);
		try {
			Date orderDate = sdf.parse(date);
			Calendar ordcal = Calendar.getInstance();
		    ordcal.setTime(orderDate);
		    ordcal.add(Calendar.DATE, 1);
            return sdf.format(ordcal.getTime());
		} catch (Exception e) {
			return getTimestampStr();
		}
	}
	
	public static String expDate(String expDate){
		String date=null;
		try {
			if(!StringUtils.isEmpty(expDate)){
				SimpleDateFormat sdf = new SimpleDateFormat("yymm");
				Date dateStr=sdf.parse(expDate);
			    sdf = new SimpleDateFormat("mmyy");
				date=sdf.format(dateStr);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		return date;
	}
	
	public boolean computeIntervalTime(Integer intervalTime, Date finishTime) {
		if (finishTime == null || intervalTime == null || intervalTime <= 0) {
			return false;
		}
		Date currentDate = new Date();
		long nextTime  = currentDate.getTime() / 60000;
		long parentTime = finishTime.getTime() / 60000;
		return nextTime - parentTime < intervalTime;
	}
	
	/**
	 * 计算毫秒数
	 * @MethodName: timeMillis
	 * @param @param hour
	 * @param @param minute
	 */
	private static long timeMillis(int hour, int minute) {
		Calendar calendar = Calendar.getInstance();
		calendar.set(Calendar.HOUR_OF_DAY, hour);
		calendar.set(Calendar.MINUTE, minute);
		return calendar.getTimeInMillis();
	}
	
	
	/**
	 * 判断当前时间是否在一定的时间范围内
	 * @param startTime
	 * @return boolean
	 */
	public static boolean isInBetweenTimes(String startTime, String endTime) {
		Date nowTime = new Date();
		SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");
		String time = sdf.format(nowTime);
		if (time.compareTo(startTime) >= 0 && time.compareTo(endTime) <= 0) {
			return true;
		} else {
			return false;
		}
	}
	
	/**
	 * 判断开始时间和结束时间，是否超出了当前时间的一定的间隔数限制, 时间单位默认为天数 如：开始时间和结束时间，不能超出距离当前时间90天
	 * @param startDate
	 *            开始时间
	 * @param endDate
	 *            结束时间按
	 * @param interval
	 *            间隔数
	 * @return
	 */
	public static boolean isOverIntervalLimit(Date startDate, Date endDate, int interval) {
		Calendar cal = Calendar.getInstance();
		cal.setTime(new Date());
		cal.add(Calendar.DAY_OF_MONTH, interval * (-1));
		Date curDate = getDayStart(cal.getTime());
		if (getDayStart(startDate).compareTo(curDate) < 0 || getDayStart(endDate).compareTo(curDate) < 0) {
			return true;
		}
		return false;
	}
	
	/**
	 * 得到day的起始时间点。
	 * @param date
	 * @return
	 */
	public static Date getDayStart(Date date) {
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(date);
		calendar.set(Calendar.HOUR_OF_DAY, 0);
		calendar.set(Calendar.MINUTE, 0);
		calendar.set(Calendar.SECOND, 0);
		calendar.set(Calendar.MILLISECOND, 0);
		return calendar.getTime();
	}
	
	/**
	 * 得到day的终止时间点.
	 * @param date
	 * @return
	 */
	public static Date getDayEnd(Date date) {
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(date);
		calendar.set(Calendar.HOUR_OF_DAY, 0);
		calendar.set(Calendar.MINUTE, 0);
		calendar.set(Calendar.SECOND, 0);
		calendar.set(Calendar.MILLISECOND, 0);
		calendar.add(Calendar.DAY_OF_MONTH, 1);
		calendar.add(Calendar.MILLISECOND, -1);
		return calendar.getTime();
	}
	
	/**
	 * 计算 second 秒后的时间
	 * @param date
	 * @param second
	 * @return
	 */
	public static Date addSecond(Date date, int second) {
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(date);
		;
		calendar.add(Calendar.SECOND, second);
		return calendar.getTime();
	}

	/**
	 * 计算 minute 分钟后的时间
	 * @param date
	 * @param minute
	 * @return
	 */
	public static Date addMinute(Date date, int minute) {
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(date);
		calendar.add(Calendar.MINUTE, minute);
		return calendar.getTime();
	}

	/**
	 * 计算 hour 小时后的时间
	 * @param date
	 * @param hour
	 * @return
	 */
	public static Date addHour(Date date, int hour) {
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(date);
		calendar.add(Calendar.HOUR, hour);
		return calendar.getTime();
	}

	/**
	 * 计算 day 天后的时间
	 * @param date
	 * @param day
	 * @return
	 */
	public static Date addDay(Date date, int day) {
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(date);
		calendar.add(Calendar.DAY_OF_MONTH, day);
		return calendar.getTime();
	}
	
	/**
	 * 字符转日期
	 * @param dateStr
	 * @return
	 */
	public static Date getDateByStr(String dateStr) {
		SimpleDateFormat formatter = null;
		if (dateStr == null) {
			return null;
		} else if (dateStr.length() == 10) {
			formatter = new SimpleDateFormat("yyyy-MM-dd");
		} else if (dateStr.length() == 16) {
			formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm");
		} else if (dateStr.length() == 19) {
			formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		} else if (dateStr.length() > 19) {
			dateStr = dateStr.substring(0, 19);
			formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		} else {
			return null;
		}
		try {
			return formatter.parse(dateStr);
		} catch (ParseException e) {
			e.printStackTrace();
			return null;
		}
	}
	
	
	/**
	 * 是否为时间格式：hh:mm:ss
	 * @param timeStr
	 * @return
	 */
	public static boolean isTime(String timeStr) {
		SimpleDateFormat df = new SimpleDateFormat("hh:mm:ss");
		Date date = null;
		try {
			date = df.parse(timeStr);
		} catch (ParseException e) {
			return false;
		}
		return date != null;
	}
	
	/**
	 * 是否为日期时间格式：yyyy-MM-dd hh:mm:ss or yyyy-MM-dd hh:mm
	 * @param dateTime
	 * @return
	 */
	public static boolean isDateTime(String dateTime) {
		int first = dateTime.indexOf(":");
		int last = dateTime.lastIndexOf(":");
		if (first == -1) {
			return false;
		}
		SimpleDateFormat df = null;
		if (first == last) {
			df = new SimpleDateFormat("yyyy-MM-dd hh:mm");
		} else {
			df = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
		}
		Date date = null;
		try {
			date = df.parse(dateTime);
		} catch (ParseException e) {
			return false;
		}
		return date == null;
	}
	
	
	/**
	 * 时间比较
	 * @param date1
	 * @param date2
	 * @return DATE1>DATE2返回1，DATE1<DATE2返回-1,等于返回0
	 */
	public static int compareDate(String date1, String date2, String format) {
		DateFormat df = new SimpleDateFormat(format);
		try {
			Date dt1 = df.parse(date1);
			Date dt2 = df.parse(date2);
			if (dt1.getTime() > dt2.getTime()) {
				return 1;
			} else if (dt1.getTime() < dt2.getTime()) {
				return -1;
			} else {
				return 0;
			}
		} catch (Exception exception) {
			exception.printStackTrace();
		}
		return 0;
	}
	
	
    
    /**
     * 给时间加上几个小时
     * @param day  当前时间 格式：yyyy-MM-dd HH:mm:ss
     * @param hour 需要加的时间
     * @return
     */
    public static String addDateHour(String day, int hour) {
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date date = null;
        try {
            date = format.parse(day);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        if (date == null)
            return "";
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        cal.add(Calendar.HOUR, hour);// 24小时制
        date = cal.getTime();
        cal = null;
        return format.format(date);
    }

    /**
     * 获取指定分钟之前的时间
     * @param minute 指定分钟
     * @return 指定分钟之前格式化后的时间 yyyy-MM-dd HH:MM
     * 保留，先，admin中
     */
    public static String getDateOfSpecifyMinuteBeFore(Long minute) {
        LocalDateTime today = LocalDateTime.now();
        LocalDateTime after = today.minus(minute, ChronoUnit.MINUTES);
        return DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm").format(after);
    }
    
   public static String compareDate(String date1, String date2) {
        DateFormat df = new SimpleDateFormat("yyyy-MM-dd hh:mm");
        try {
            Date dt1 = df.parse(date1);
            Date dt2 = df.parse(date2);
            if (dt1.getTime() > dt2.getTime()) {
                return date1;
            } else if (dt1.getTime() < dt2.getTime()) {
                return date2;
            } else {
                return date1;
            }
        } catch (Exception exception) {
            exception.printStackTrace();
        }
        return date1;
    }
   
   /**
    * 获取两个时间相差分钟数
    * @param start
    * @param end
    * @return 分钟数
    */
   public static int getTimeDifference(String start,String end){
       //把当前时间和要比较的时间转换为Date类型，目的在于得到这两个时间的毫秒值
       SimpleDateFormat sdf = new SimpleDateFormat("HH:mm");
       Date parse = null;
       Date now = null;
       try {
           parse = sdf.parse(start);
           now = sdf.parse(end);
       } catch (ParseException e) {
       }
       //获得这两个时间的毫秒值后进行处理(因为我的需求不需要处理时间大小，所以此处没有处理，可以判断一下哪个大就用哪个作为减数。)
       long diff = now.getTime() - parse.getTime();
       //此处用毫秒值除以分钟再除以毫秒既得两个时间相差的分钟数
       long minute = diff/60/1000;
       return (int)minute;
   }
   
   public static String simpleDatetime(String datetime) {
		if (datetime == null) {
			return "";
		}
		if (datetime.matches("\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}")) {
			return datetime.substring(5, 16);
		} else if (datetime.matches("\\d{4}-\\d{2}-\\d{2}")) {
			return datetime.substring(5, 10);
		} else if (datetime.matches("\\d{2}:\\d{2}:\\d{2}")) {
			return datetime.substring(0, 5);
		}
		return datetime;
	}
   
   // 判断是否在可用时间内
   public static long DEFAULT_TIMEOUT_SECOND = 70 * 60 * 1000;
   public static boolean isUsable(Date date) {
       if (null == date) {
           return false;
       }
       if (new Date().getTime() - date.getTime() > DEFAULT_TIMEOUT_SECOND) {
           return false;
       }
       return true;
   }
   
   /**
    * 获取前一天0点时间
    * @param date
    * @return
    */
   public static Date getStartOfYesterday(Date date) {
       long zero = System.currentTimeMillis() / (1000 * 3600 * 24) * (1000 * 3600 * 24) - TimeZone.getDefault().getRawOffset();
       zero = zero - 1000 * 3600 * 24;
       return new Date(zero);
   }

   /**
    * 获取前一天23:59
    * @param date
    * @return
    */
   public static Date getEndOfYesterday(Date date) {
       long zero = getStartOfYesterday(new Date()).getTime();
       return new Date(zero + 1000 * 3600 * 24 - 1);
   }

    public static void main(String[] args) {
    	 //获取10分钟之前的时间
        String specifyMinutesDate = DateUtil.getDateOfSpecifyMinuteBeFore(10L);
        System.out.println(specifyMinutesDate);
        Date now = new Date();
        Date date=DateUtil.getStartOfYesterday(now);
        System.out.println(date);
	}

}
